package org.aplombh.java.awcing.basic.dp.treeDP;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

/**
 * Ural 大学有 N 名职员，编号为 1∼N。
 * <p>
 * 他们的关系就像一棵以校长为根的树，父节点就是子节点的直接上司。
 * <p>
 * 每个职员有一个快乐指数，用整数 Hi 给出，其中 1≤i≤N。
 * <p>
 * 现在要召开一场周年庆宴会，不过，没有职员愿意和直接上司一起参会。
 * <p>
 * 在满足这个条件的前提下，主办方希望邀请一部分职员参会，使得所有参会职员的快乐指数总和最大，求这个最大值。
 * <p>
 * 输入格式
 * 第一行一个整数 N。
 * <p>
 * 接下来 N 行，第 i 行表示 i 号职员的快乐指数 Hi。
 * <p>
 * 接下来 N−1 行，每行输入一对整数 L,K，表示 K 是 L 的直接上司。
 * <p>
 * 输出格式
 * 输出最大的快乐指数。
 * <p>
 * 数据范围
 * 1≤N≤6000,
 * −128≤Hi≤127
 * 输入样例：
 * 7
 * 1
 * 1
 * 1
 * 1
 * 1
 * 1
 * 1
 * 1 3
 * 2 3
 * 6 4
 * 7 4
 * 4 5
 * 3 5
 * 输出样例：
 * 5
 */
public class PartyWithoutBoss_285 {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(reader.readLine());
        PartyWithoutBoss pwb = new PartyWithoutBoss();
        for (int i = 1; i <= n; i++) {
            pwb.happy[i] = Integer.parseInt(reader.readLine());
        }
        for (int i = 1; i < n; i++) {
            String s = reader.readLine();
            int a = Integer.parseInt(s.split(" ")[0]);
            int b = Integer.parseInt(s.split(" ")[1]);
            pwb.has_father[a] = true;
            pwb.add(b, a);
        }
        pwb.solve();
    }
}

class PartyWithoutBoss {
    public static final int N = 6010;

    int[] happy = new int[N];
    int[] h = new int[N];
    int[] e = new int[N];
    int[] ne = new int[N];
    int idx;
    int[][] f = new int[N][2];
    boolean[] has_father = new boolean[N];

    PartyWithoutBoss(){
        Arrays.fill(h,-1);
    }

    public void add(int a, int b) {
        e[idx] = b;
        ne[idx] = h[a];
        h[a] = idx++;
    }

    public void solve() {
        int root = 1;
        // 找到根节点
        while (has_father[root]) root++;
        dfs(root);
        System.out.println(Math.max(f[root][0], f[root][1]));
    }

    private void dfs(int u) {
        // 选该点
        f[u][1] = happy[u];

        // 遍历所有子节点
        for (int i = h[u]; i != -1; i = ne[i]) {
            int j = e[i];
            // 求子节点
            dfs(j);

            // 将所有子节点的最大值相加
            f[u][0] += Math.max(f[j][0], f[j][1]);
            // 选该点之后,子节点必须选
            f[u][1] += f[j][0];
        }
    }
}
